import { ref, reactive, computed } from 'vue';

/**
 * 表单验证组合式函数
 * 提供表单字段验证、错误处理等功能
 */
export function useValidator() {
  // 存储表单验证状态
  const validationState = reactive({
    errors: {},
    isValid: true
  });

  // 验证规则集合
  const rules = {
    // 必填验证
    required: (value, message = '此字段为必填项') => {
      if (value === undefined || value === null || value === '') {
        return message;
      }
      return '';
    },

    // 角色编码验证
    code: (value, message = '请输入有效的角色编码（字母、数字、下划线组合）') => {
      if (value && !/^[a-zA-Z0-9_]+$/.test(value)) {
        return message;
      }
      return '';
    },

    // 最小长度验证
    minLength: (value, min, message = `最少需要${min}个字符`) => {
      if (value && value.length < min) {
        return message;
      }
      return '';
    },

    // 最大长度验证
    maxLength: (value, max, message = `最多只能输入${max}个字符`) => {
      if (value && value.length > max) {
        return message;
      }
      return '';
    },

    // 邮箱格式验证
    email: (value, message = '请输入有效的邮箱地址') => {
      if (value && !/^[a-zA-Z0-9._-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,6}$/.test(value)) {
        return message;
      }
      return '';
    },

    // 手机号格式验证
    phone: (value, message = '请输入有效的手机号码') => {
      if (value && !/^1[3-9]\d{9}$/.test(value)) {
        return message;
      }
      return '';
    },

    // 数字验证
    number: (value, message = '请输入有效数字') => {
      if (value && isNaN(Number(value))) {
        return message;
      }
      return '';
    },

    // 正整数验证
    positiveInteger: (value, message = '请输入正整数') => {
      if (value && !/^[1-9]\d*$/.test(value)) {
        return message;
      }
      return '';
    },

    // 网址格式验证
    url: (value, message = '请输入有效的网址') => {
      if (value && !/^(https?:\/\/)?([\da-z.-]+)\.([a-z.]{2,6})([/\w.-]*)*\/?$/.test(value)) {
        return message;
      }
      return '';
    },

    // 自定义正则表达式验证
    pattern: (value, regex, message) => {
      if (value && !regex.test(value)) {
        return message;
      }
      return '';
    },

    // 自定义函数验证
    custom: (value, validatorFn, message) => {
      if (typeof validatorFn === 'function' && !validatorFn(value)) {
        return message;
      }
      return '';
    },

    // 确认密码验证
    confirmPassword: (value, password, message = '两次输入的密码不一致') => {
      if (value !== password) {
        return message;
      }
      return '';
    }
  };

  /**
   * 验证单个字段
   * @param {string} fieldName - 字段名
   * @param {any} value - 字段值
   * @param {Array} fieldRules - 字段验证规则数组
   * @returns {boolean} 字段是否验证通过
   */
  const validateField = (fieldName, value, fieldRules) => {
    let error = '';
    
    for (const rule of fieldRules) {
      // 处理函数形式的规则
      if (typeof rule === 'function') {
        error = rule(value);
      }
      // 处理对象形式的规则
      else if (typeof rule === 'object') {
        const [ruleName, ...args] = Object.entries(rule)[0];
        if (rules[ruleName]) {
          error = rules[ruleName](value, ...args);
        }
      }
      // 处理字符串形式的规则
      else if (typeof rule === 'string' && rules[rule]) {
        error = rules[rule](value);
      }

      // 如果有错误，停止验证
      if (error) {
        break;
      }
    }

    // 更新错误状态
    validationState.errors[fieldName] = error;
    return !error;
  };

  /**
   * 验证整个表单
   * @param {Object} formData - 表单数据
   * @param {Object} formRules - 表单验证规则
   * @returns {boolean} 表单是否验证通过
   */
  const validateForm = (formData, formRules) => {
    let isValid = true;
    // 清空之前的错误
    validationState.errors = {};

    // 验证每个字段
    for (const [fieldName, fieldRules] of Object.entries(formRules)) {
      const fieldIsValid = validateField(fieldName, formData[fieldName], fieldRules);
      isValid = isValid && fieldIsValid;
    }

    validationState.isValid = isValid;
    return isValid;
  };

  /**
   * 清除指定字段的错误
   * @param {string} fieldName - 字段名
   */
  const clearError = (fieldName) => {
    if (validationState.errors[fieldName]) {
      delete validationState.errors[fieldName];
    }
  };

  /**
   * 清除所有错误
   */
  const clearAllErrors = () => {
    validationState.errors = {};
    validationState.isValid = true;
  };

  /**
   * 获取指定字段的错误信息
   * @param {string} fieldName - 字段名
   * @returns {string} 错误信息
   */
  const getError = (fieldName) => {
    return validationState.errors[fieldName] || '';
  };

  /**
   * 检查字段是否有错误
   * @param {string} fieldName - 字段名
   * @returns {boolean} 是否有错误
   */
  const hasError = (fieldName) => {
    return !!validationState.errors[fieldName];
  };

  /**
   * 验证规则便捷函数 - 必填
   * @param {string} message - 错误信息
   * @returns {Object} 规则对象
   */
  const required = (message) => ({
    required: message || undefined
  });

  /**
   * 验证规则便捷函数 - 最小长度
   * @param {number} min - 最小长度
   * @param {string} message - 错误信息
   * @returns {Object} 规则对象
   */
  const minLength = (min, message) => ({
    minLength: [min, message || undefined]
  });

  /**
   * 验证规则便捷函数 - 最大长度
   * @param {number} max - 最大长度
   * @param {string} message - 错误信息
   * @returns {Object} 规则对象
   */
  const maxLength = (max, message) => ({
    maxLength: [max, message || undefined]
  });

  /**
   * 验证规则便捷函数 - 邮箱
   * @param {string} message - 错误信息
   * @returns {Object} 规则对象
   */
  const email = (message) => ({
    email: message || undefined
  });

  /**
   * 验证规则便捷函数 - 手机号
   * @param {string} message - 错误信息
   * @returns {Object} 规则对象
   */
  const phone = (message) => ({
    phone: message || undefined
  });

  /**
   * 验证规则便捷函数 - 自定义函数
   * @param {Function} validatorFn - 验证函数
   * @param {string} message - 错误信息
   * @returns {Object} 规则对象
   */
  const custom = (validatorFn, message) => ({
    custom: [validatorFn, message]
  });

  // 导出功能
  return {
    // 验证状态
    errors: computed(() => validationState.errors),
    isValid: computed(() => validationState.isValid),
    
    // 验证方法
    validateField,
    validateForm,
    clearError,
    clearAllErrors,
    getError,
    hasError,
    
    // 便捷规则创建函数
    required,
    minLength,
    maxLength,
    email,
    phone,
    custom,
    
    // 特定验证函数（用于兼容已有组件）
    validateRequired: rules.required,
    validateCode: rules.code,
    
    // 原始规则对象
    rules
  };
}